home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet multimedia / Animacje, filmy i prezentacje / Modelowanie 3D / K-3D 0.6.5.0 / k3d-all-in-one-setup-0.6.5.0.exe / aqsis-setup-1.1.0-2006-12-09.exe / include / aqsis / refcount.h < prev    next >
Encoding:
C/C++ Source or Header  |  2005-12-11  |  4.3 KB  |  145 lines
  1. //------------------------------------------------------------------------------
  2. /**
  3.  *    @file    refcount.h
  4.  *    @author    Paul Gregory
  5.  *    @brief    Declare a reference counting class.
  6.  *
  7.  *    Last change by:        $Author: pgregory $
  8.  *    Last change date:    $Date: 2005-12-11 20:32:46 +0000 (Sun, 11 Dec 2005) $
  9.  */
  10. //------------------------------------------------------------------------------
  11.  
  12. #ifndef    ___refcount_Loaded___
  13. #define    ___refcount_Loaded___
  14.  
  15. #include    "aqsis.h"
  16. #include    "sstring.h"
  17. #include    <vector>
  18. #include    <list>
  19.  
  20. /**
  21.  * These are debug and non-debug versions of the macros ADDREF and RELEASEREF.
  22.  *
  23.  * ADDREF increments the reference count of a pointer to a CqRefCount-derived 
  24.  * class, while RELEASEREF decrements the reference count, causing the object 
  25.  * to be freed when the reference count is less than or equal to zero.
  26.  * 
  27.  * The non-debug versions simply call AddRef() and Release() methods on the
  28.  * object (which is assumed to be a pointer to a CqRefCount-derived class).  
  29.  * The debug versions include the file name and line where the macro was 
  30.  * called, to enable this information to be tracked for debugging purposes.
  31.  */
  32. #ifdef _DEBUG
  33. #define ADDREF(x) (x)->AddRef(__FILE__, __LINE__)
  34. #define RELEASEREF(x) (x)->Release(__FILE__, __LINE__)
  35. #else
  36. #define ADDREF(x) (x)->AddRef()
  37. #define RELEASEREF(x) (x)->Release()
  38. #endif
  39.  
  40. #ifdef _DEBUG
  41. // report_refcounts() should be called at the end of rendering, at such a
  42. // time when all reference-counted objects should have been released.
  43. #ifdef    AQSIS_SYSTEM_WIN32
  44. extern "C" __declspec(dllexport) void report_refcounts();
  45. #else
  46. extern "C" void report_refcounts();
  47. #endif    // AQSIS_SYSTEM_WIN32
  48.  
  49. class RefCountRecord;
  50. typedef std::vector<RefCountRecord*> RecordVector;
  51. typedef std::vector<RefCountRecord*>::iterator RecordIterator;
  52. typedef std::vector<RefCountRecord*>::const_iterator ConstRecordIterator;
  53. #endif
  54.  
  55. /**
  56.  * \class CqRefCount
  57.  *
  58.  * This class provides a reference counting form of memory management for
  59.  * Aqsis.
  60.  *
  61.  * This class is implemented in two different ways.  One way is a debug
  62.  * version, which keeps track of AddRef() and Release() calls so that bugs
  63.  * can be tracked easily.  The second version is a much faster, minimal
  64.  * implementation that is used for non-debug builds.
  65.  * 
  66.  * The basic idea with this class is that derived classes will have the
  67.  * AddRef() function called whenever a new object needs access to the
  68.  * derived class.  Calling AddRef() effectively marks the derived class as
  69.  * "in use", and prevents it from being de-allocated.  When the object no 
  70.  * longer needs the derived class, it will call Release().  Finally, when 
  71.  * the last class has called Release(), the reference counter realises
  72.  * that nobody needs it anymore and automatically deletes itself.
  73.  */
  74. class CqRefCount
  75. {
  76.  
  77. #ifdef _DEBUG
  78.  
  79.     public:
  80.         /// These methods are the debug versions.
  81.         CqRefCount();
  82.         CqRefCount( const CqRefCount& From );
  83.         virtual ~CqRefCount();
  84.         TqInt RefCount() const;
  85.         void AddRef(const TqChar* file, TqInt line);
  86.         void Release(const TqChar* file, TqInt line);
  87.         void dump() const;
  88.         /**
  89.          * Returns the name of the class.  This function can be
  90.          * overridden in sub-classes to provide better debugging
  91.          * information.  Remember to only include it if _DEBUG
  92.          * is defined.
  93.          */
  94.         virtual Aqsis::CqString className() const
  95.         {
  96.             return Aqsis::CqString("unknown");
  97.         }
  98.  
  99.     private:
  100.         /// Record of reference counting events for this
  101.         ///  particular instance of CqRefCount.
  102.         RecordVector m_records;
  103.         /// Flag that, when true, indicates that the instance had
  104.         ///  ADDREF called at least once.
  105.         TqBool m_addRefCalled;
  106.  
  107. #else ///< #ifdef _DEBUG
  108.  
  109.         /// The methods below are inlined for use in a non-debug
  110.         ///  compile.
  111.     public:
  112.         /// Constructor
  113.         CqRefCount() : m_cReferences( 0 )
  114.         {}
  115.  
  116.         /// Copy Constructor, does not copy reference count.
  117.         CqRefCount( const CqRefCount& From )
  118.         {}
  119.         virtual ~CqRefCount()
  120.         {}
  121.  
  122.         TqInt    RefCount() const
  123.         {
  124.             return ( m_cReferences );
  125.         }
  126.         void    AddRef()
  127.         {
  128.             m_cReferences++;
  129.         }
  130.         void    Release()
  131.         {
  132.             m_cReferences--;
  133.             if ( m_cReferences <= 0 )
  134.                 delete( this );
  135.         }
  136.  
  137. #endif ///< #ifdef _DEBUG
  138.  
  139.     private:
  140.         TqInt    m_cReferences;        ///< Count of references to this object.
  141. };
  142.  
  143.  
  144. #endif    //    ___refcount_Loaded___
  145.